home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 051-075 / scopedisk53 / memmometer / mminit3.c < prev   
C/C++ Source or Header  |  1995-03-18  |  21KB  |  632 lines
  1. /* : ai=0 bk=0 ts=8 */
  2. #include "mm.h"
  3.  
  4. #define PROJMAX 3               /* number of project menu items */
  5. #define SETUPMAX 2              /* number of setup menu items */
  6. #define MODEMAX 2
  7. #define FREQMAX 4               /* number of frequency menu items */
  8. #define CHIPMAX 5               /* number of chip mem size menu items */
  9. #define CHIPAMAX 4              /* number of chip mem base addr menu items */
  10. #define SFMAX 4                 /* number of sf mem size menu items */
  11. #define SFAMAX 4                /* number of sf mem base addr menu items */
  12. #define FASTMAX 7               /* number of fast mem size menu items */
  13. #define FASTAMAX 8              /* number of fast mem base addr menu items */
  14. #define MAXMENU 9               /* total number of top level menus */
  15.  
  16. extern BOOL p_mode;             /* preset frags mode = 0, warps mode = 1 */
  17. extern long p_rate;             /* preset sample interval, secs see menu */
  18. extern long p_chip;             /* preset chip mem size, kbytes see menu */
  19. extern long p_chipa;            /* preset chip mem address, kb  see menu */
  20. extern long p_sf;               /* preset slowfast mem size, kb see menu */
  21. extern long p_sfa;              /* preset slowfast mem addr, kb see menu */
  22. extern long p_fast;             /* preset fast mem size, mbytes see menu */
  23. extern long p_fasta;            /* preset fast mem addr, mbytes see menu */
  24.  
  25. /******************************************************/
  26. /*    Structure declarations for the menu sections    */
  27. /******************************************************/
  28.  
  29. struct   MenuItem ProjItem[PROJMAX];
  30. struct   IntuiText ProjText[PROJMAX];
  31. struct   MenuItem SetupItem[SETUPMAX];
  32. struct   IntuiText SetupText[SETUPMAX];
  33. struct   MenuItem ModeItem[MODEMAX];
  34. struct   IntuiText ModeText[MODEMAX];
  35. struct   MenuItem FreqItem[FREQMAX];
  36. struct   IntuiText FreqText[FREQMAX];
  37. struct   MenuItem ChipItem[CHIPMAX];
  38. struct   IntuiText ChipText[CHIPMAX];
  39. struct   MenuItem ChipAItem[CHIPAMAX];
  40. struct   IntuiText ChipAText[CHIPAMAX];
  41. struct   MenuItem SFItem[SFMAX];
  42. struct   IntuiText SFText[SFMAX];
  43. struct   MenuItem SFAItem[SFAMAX];
  44. struct   IntuiText SFAText[SFAMAX];
  45. struct   MenuItem FastItem[FASTMAX];
  46. struct   IntuiText FastText[FASTMAX];
  47. struct   MenuItem FastAItem[FASTAMAX];
  48. struct   IntuiText FastAText[FASTAMAX];
  49. struct   Menu menu[MAXMENU];
  50.  
  51. /*****************************************************************/
  52. /*    The following function initializes the structure arrays    */
  53. /*    needed to provide the Project menu topic.                  */
  54. /*    this was left retro-compatible with Manx 3.4a (nplus1)     */
  55. /*****************************************************************/
  56. void InitProjItems()
  57.     {
  58.     int       n,nplus1;
  59.  
  60. /* initialize each menu item and IntuiText with loop */
  61. for( n=0; n<PROJMAX; n++ )
  62.     {
  63.     nplus1 = n + 1;
  64.     ProjItem[n].NextItem = &ProjItem[nplus1];
  65.     ProjItem[n].LeftEdge = 0;
  66.     ProjItem[n].TopEdge = 9 * n;
  67.     ProjItem[n].Width = 64;
  68.     ProjItem[n].Height = 9;
  69.     ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
  70.     ProjItem[n].MutualExclude = 0;
  71.     ProjItem[n].ItemFill = (APTR)&ProjText[n];
  72.     ProjItem[n].SelectFill = NULL;
  73.     ProjItem[n].Command = 0;
  74.     ProjItem[n].SubItem = NULL;
  75.     ProjItem[n].NextSelect = 0;
  76.  
  77.     ProjText[n].FrontPen = 0;
  78.     ProjText[n].BackPen = 1;
  79.     ProjText[n].DrawMode = JAM2;/* render in fore and background */
  80.     ProjText[n].LeftEdge = 0;
  81.     ProjText[n].TopEdge = 1;
  82.     ProjText[n].ITextFont = NULL;
  83.     ProjText[n].NextText = NULL;
  84.     }
  85. ProjItem[PROJMAX-1].NextItem = NULL;
  86.  
  87. /* initialize text for specific menu items */
  88.  
  89. ProjText[0].IText = (UBYTE *)"Front";
  90. ProjText[1].IText = (UBYTE *)"Back";
  91. ProjText[2].IText = (UBYTE *)"Close";
  92. }
  93.  
  94. /*****************************************************************/
  95. /*    The following initializes the structure arrays             */
  96. /*   needed to provide the Setup menu topic.                     */
  97. /*****************************************************************/
  98.  
  99. void InitSetupItems()
  100.     {
  101.     int       n,nplus1;
  102.  
  103. /* initialize each menu item and IntuiText with loop */
  104. for( n=0; n<SETUPMAX; n++ )
  105.     {
  106.     nplus1 = n + 1;
  107.     SetupItem[n].NextItem = &SetupItem[nplus1];
  108.     SetupItem[n].LeftEdge = 0;
  109.     SetupItem[n].TopEdge = 9 * n;
  110.     SetupItem[n].Width = 44;
  111.     SetupItem[n].Height = 9;
  112.     SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
  113.     SetupItem[n].MutualExclude = 0;
  114.     SetupItem[n].ItemFill = (APTR)&SetupText[n];
  115.     SetupItem[n].SelectFill = NULL;
  116.     SetupItem[n].Command = 0;
  117.     SetupItem[n].NextSelect = 0;
  118.  
  119.     SetupText[n].FrontPen = 0;
  120.     SetupText[n].BackPen = 1;
  121.     SetupText[n].DrawMode = JAM2;
  122.     SetupText[n].LeftEdge = 0;
  123.     SetupText[n].TopEdge = 1;
  124.     SetupText[n].ITextFont = NULL;
  125.     SetupText[n].NextText = NULL;
  126.     }
  127. SetupItem[SETUPMAX-1].NextItem = NULL;
  128.  
  129. SetupText[0].IText = (UBYTE *)"Mode";
  130. SetupItem[0].SubItem = ModeItem;
  131. SetupText[1].IText = (UBYTE *)"Freq";
  132. SetupItem[1].SubItem = FreqItem;
  133.  
  134. /*****************************************************************/
  135. /*    The following initializes the structure arrays             */
  136. /*   needed to provide the Mode submenu topic.                   */
  137. /*****************************************************************/
  138.  
  139. for( n=0; n<MODEMAX; n++ )
  140.     {
  141.     nplus1 = n + 1;
  142.     ModeItem[n].NextItem = &ModeItem[nplus1];
  143.     ModeItem[n].LeftEdge = 38;
  144.     ModeItem[n].TopEdge = 9 * n;
  145.     ModeItem[n].Width = 72;
  146.     ModeItem[n].Height = 9;
  147.     ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  148.     ModeItem[n].MutualExclude = (~(1 << n));
  149.     ModeItem[n].ItemFill = (APTR)&ModeText[n];
  150.     ModeItem[n].SelectFill = NULL;
  151.     ModeItem[n].Command = 0;
  152.     ModeItem[n].SubItem = NULL;
  153.     ModeItem[n].NextSelect = 0;
  154.  
  155.     ModeText[n].FrontPen = 0;
  156.     ModeText[n].BackPen = 1;
  157.     ModeText[n].DrawMode = JAM2;     /* render in fore and background */
  158.     ModeText[n].LeftEdge = 0;
  159.     ModeText[n].TopEdge = 1;
  160.     ModeText[n].ITextFont = NULL;
  161.     ModeText[n].NextText = NULL;
  162.     }
  163. ModeItem[MODEMAX-1].NextItem = NULL;
  164.  
  165. /* select mode subitem checked */
  166. switch (p_mode) {
  167.     case 0:     n = 0; break;
  168.     case 1:     n = 1; break;
  169.     default:    n = 1; p_mode = FALSE;
  170.     }
  171. ModeItem[n].Flags |= CHECKED;
  172.  
  173. /* initialize text for specific submenu items */
  174. ModeText[0].IText = (UBYTE *)"   Frags";
  175. ModeText[1].IText = (UBYTE *)"   Warps";
  176.  
  177. /*****************************************************************/
  178. /*    The following initializes the structure arrays             */
  179. /*   needed to provide the Freq submenu topic.                   */
  180. /*****************************************************************/
  181.  
  182. for( n=0; n<FREQMAX; n++ )
  183.     {
  184.     nplus1 = n + 1;
  185.     FreqItem[n].NextItem = &FreqItem[nplus1];
  186.     FreqItem[n].LeftEdge = 38;
  187.     FreqItem[n].TopEdge = 9 * n;
  188.     FreqItem[n].Width = 88;
  189.     FreqItem[n].Height = 9;
  190.     FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  191.     FreqItem[n].MutualExclude = (~(1 << n));
  192.     FreqItem[n].ItemFill = (APTR)&FreqText[n];
  193.     FreqItem[n].SelectFill = NULL;
  194.     FreqItem[n].Command = 0;
  195.     FreqItem[n].SubItem = NULL;
  196.     FreqItem[n].NextSelect = 0;
  197.  
  198.     FreqText[n].FrontPen = 0;
  199.     FreqText[n].BackPen = 1;
  200.     FreqText[n].DrawMode = JAM2;     /* render in fore and background */
  201.     FreqText[n].LeftEdge = 0;
  202.     FreqText[n].TopEdge = 1;
  203.     FreqText[n].ITextFont = NULL;
  204.     FreqText[n].NextText = NULL;
  205.     }
  206. FreqItem[FREQMAX-1].NextItem = NULL;
  207.  
  208. /* select frequency item checked */
  209. switch (p_rate) {
  210.     case 1:     n = 0; break;
  211.     case 2:     n = 1; break;
  212.     case 5:     n = 2; break;
  213.     case 10:    n = 3; break;
  214.     default:    n = 1; p_rate = 2;
  215.     }
  216. FreqItem[n].Flags |= CHECKED;
  217.  
  218. /* initialize text for specific menu items */
  219. FreqText[0].IText = (UBYTE *)"    1 Sec ";
  220. FreqText[1].IText = (UBYTE *)"    2 Secs";
  221. FreqText[2].IText = (UBYTE *)"    5 Secs";
  222. FreqText[3].IText = (UBYTE *)"   10 Secs";
  223. }
  224.  
  225. /*****************************************************************/
  226. /*    The following initializes the structure arrays             */
  227. /*   needed to provide the Chip Mem Size menu topic.             */
  228. /*****************************************************************/
  229.  
  230. void InitChipItems()
  231.     {
  232.     int       n,nplus1;
  233.  
  234. /* initialize each menu item and IntuiText with loop */
  235. for( n=0; n<CHIPMAX; n++ )
  236.     {
  237.     nplus1 = n + 1;
  238.     ChipItem[n].NextItem = &ChipItem[nplus1];
  239.     ChipItem[n].LeftEdge = 0;
  240.     ChipItem[n].TopEdge = 9 * n;
  241.     ChipItem[n].Width = 80;
  242.     ChipItem[n].Height = 9;
  243.     ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  244.     ChipItem[n].MutualExclude = (~(1 << n));
  245.     ChipItem[n].ItemFill = (APTR)&ChipText[n];
  246.     ChipItem[n].SelectFill = NULL;
  247.     ChipItem[n].Command = 0;
  248.     ChipItem[n].NextSelect = 0;
  249.  
  250.     ChipText[n].FrontPen = 0;
  251.     ChipText[n].BackPen = 1;
  252.     ChipText[n].DrawMode = JAM2;
  253.     ChipText[n].LeftEdge = 0;
  254.     ChipText[n].TopEdge = 1;
  255.     ChipText[n].ITextFont = NULL;
  256.     ChipText[n].NextText = NULL;
  257.     }
  258. ChipItem[CHIPMAX-1].NextItem = NULL;
  259.  
  260. /* select chip mem size item checked */
  261. switch (p_chip) {
  262.     case    0:     n = 0; break;
  263.     case  256:     n = 1; break;
  264.     case  512:     n = 2; break;
  265.     case 1024:     n = 3; break;
  266.     case 2048:     n = 4; break;
  267.     default:       n = 2; p_chip = 512;
  268.     }
  269. ChipItem[n].Flags |= CHECKED;
  270.  
  271. ChipText[0].IText = (UBYTE *)"   NONE";
  272. ChipText[1].IText = (UBYTE *)"   256K";
  273. ChipText[2].IText = (UBYTE *)"   512K";
  274. ChipText[3].IText = (UBYTE *)"   1 MB";
  275. ChipText[4].IText = (UBYTE *)"   2 MB";
  276. }
  277.  
  278. /*****************************************************************/
  279. /*    The following initializes the structure arrays             */
  280. /*   needed to provide the Chip Base Addr menu topic.            */
  281. /*****************************************************************/
  282.  
  283. void InitChipAItems()
  284.     {
  285.     int       n,nplus1;
  286.  
  287. /* initialize each menu item and IntuiText with loop */
  288. for( n=0; n<CHIPAMAX; n++ )
  289.     {
  290.     nplus1 = n + 1;
  291.     ChipAItem[n].NextItem = &ChipAItem[nplus1];
  292.     ChipAItem[n].LeftEdge = 0;
  293.     ChipAItem[n].TopEdge = 9 * n;
  294.     ChipAItem[n].Width = 80;
  295.     ChipAItem[n].Height = 9;
  296.     ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  297.     ChipAItem[n].MutualExclude = (~(1 << n));
  298.     ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
  299.     ChipAItem[n].SelectFill = NULL;
  300.     ChipAItem[n].Command = 0;
  301.     ChipAItem[n].NextSelect = 0;
  302.  
  303.     ChipAText[n].FrontPen = 0;
  304.     ChipAText[n].BackPen = 1;
  305.     ChipAText[n].DrawMode = JAM2;
  306.     ChipAText[n].LeftEdge = 0;
  307.     ChipAText[n].TopEdge = 1;
  308.     ChipAText[n].ITextFont = NULL;
  309.     ChipAText[n].NextText = NULL;
  310.     }
  311. ChipAItem[CHIPAMAX-1].NextItem = NULL;
  312.  
  313. /* select chip base address item checked */
  314. switch (p_chipa) {
  315.     case    0:     n = 0; break;
  316.     case  256:     n = 1; break;
  317.     case  512:     n = 2; break;
  318.     case 1024:     n = 3; break;
  319.     default:       n = 0; p_chipa = 0;
  320.     }
  321. ChipAItem[n].Flags |= CHECKED;
  322.  
  323. ChipAText[0].IText = (UBYTE *)"   @   0K";
  324. ChipAText[1].IText = (UBYTE *)"   @ 256K";
  325. ChipAText[2].IText = (UBYTE *)"   @ 512K";
  326. ChipAText[3].IText = (UBYTE *)"   @ 1 MB";
  327. }
  328.  
  329. /*****************************************************************/
  330. /*    The following initializes the structure arrays             */
  331. /*   needed to provide the Slow Fast Mem Size menu topic.        */
  332. /*****************************************************************/
  333.  
  334. void InitSFItems()
  335.     {
  336.     int       n,nplus1;
  337.  
  338. /* initialize each menu item and IntuiText with loop */
  339. for( n=0; n<SFMAX; n++ )
  340.     {
  341.     nplus1 = n + 1;
  342.     SFItem[n].NextItem = &SFItem[nplus1];
  343.     SFItem[n].LeftEdge = 0;
  344.     SFItem[n].TopEdge = 9 * n;
  345.     SFItem[n].Width = 80;
  346.     SFItem[n].Height = 9;
  347.     SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  348.     SFItem[n].MutualExclude = (~(1 << n));
  349.     SFItem[n].ItemFill = (APTR)&SFText[n];
  350.     SFItem[n].SelectFill = NULL;
  351.     SFItem[n].Command = 0;
  352.     SFItem[n].NextSelect = 0;
  353.  
  354.     SFText[n].FrontPen = 0;
  355.     SFText[n].BackPen = 1;
  356.     SFText[n].DrawMode = JAM2;
  357.     SFText[n].LeftEdge = 0;
  358.     SFText[n].TopEdge = 1;
  359.     SFText[n].ITextFont = NULL;
  360.     SFText[n].NextText = NULL;
  361.     }
  362. SFItem[SFMAX-1].NextItem = NULL;
  363.  
  364. /* select slow fast mem size item checked */
  365. switch (p_sf) {
  366.     case    0:     n = 0; break;
  367.     case  512:     n = 1; break;
  368.     case 1024:     n = 2; break;
  369.     case 1536:     n = 3; break;
  370.     default:       n = 1; p_sf = 512;
  371.     }
  372. SFItem[n].Flags |= CHECKED;
  373.  
  374. SFText[0].IText = (UBYTE *)"   NONE  ";
  375. SFText[1].IText = (UBYTE *)"   0.5 MB";
  376. SFText[2].IText = (UBYTE *)"   1   MB";
  377. SFText[3].IText = (UBYTE *)"   1.5 MB";
  378. }
  379.  
  380. /*****************************************************************/
  381. /*    The following initializes the structure arrays             */
  382. /*   needed to provide the Slow Fast Mem Base Addr menu topic.   */
  383. /*****************************************************************/
  384.  
  385. void InitSFAItems()
  386.     {
  387.     int       n,nplus1;
  388.  
  389. /* initialize each menu item and IntuiText with loop */
  390. for( n=0; n<SFAMAX; n++ )
  391.     {
  392.     nplus1 = n + 1;
  393.     SFAItem[n].NextItem = &SFAItem[nplus1];
  394.     SFAItem[n].LeftEdge = 0;
  395.     SFAItem[n].TopEdge = 9 * n;
  396.     SFAItem[n].Width = 104;
  397.     SFAItem[n].Height = 9;
  398.     SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  399.     SFAItem[n].MutualExclude = (~(1 << n));
  400.     SFAItem[n].ItemFill = (APTR)&SFAText[n];
  401.     SFAItem[n].SelectFill = NULL;
  402.     SFAItem[n].Command = 0;
  403.     SFAItem[n].NextSelect = 0;
  404.  
  405.     SFAText[n].FrontPen = 0;
  406.     SFAText[n].BackPen = 1;
  407.     SFAText[n].DrawMode = JAM2;
  408.     SFAText[n].LeftEdge = 0;
  409.     SFAText[n].TopEdge = 1;
  410.     SFAText[n].ITextFont = NULL;
  411.     SFAText[n].NextText = NULL;
  412.     }
  413. SFAItem[SFAMAX-1].NextItem = NULL;
  414.  
  415. /* select slow fast mem base address item checked */
  416. switch (p_sfa) {
  417.     case 12288:     n = 0; break;               /* 0x3000 kb = 12   mb */
  418.     case 12800:     n = 1; break;               /* 0x3200 kb = 12.5 mb */
  419.     case 13312:     n = 2; break;               /* 0x3400 kb = 13   mb */
  420.     case 13824:     n = 3; break;               /* 0x3600 kb = 13.5 mb */
  421.     default:        n = 0; p_sfa = 12288;
  422.     }
  423. SFAItem[n].Flags |= CHECKED;
  424.  
  425. SFAText[0].IText = (UBYTE *)"   @ C.0 Meg";
  426. SFAText[1].IText = (UBYTE *)"   @ C.8 Meg";
  427. SFAText[2].IText = (UBYTE *)"   @ D.0 Meg";
  428. SFAText[3].IText = (UBYTE *)"   @ D.8 Meg";
  429. }
  430.  
  431. /*****************************************************************/
  432. /*    The following initializes the structure arrays             */
  433. /*   needed to provide the Fast Mem Size menu topic.             */
  434. /*****************************************************************/
  435.  
  436. void InitFastItems()
  437.     {
  438.     int       n,nplus1;
  439.  
  440. /* initialize each menu item and IntuiText with loop */
  441. for( n=0; n<FASTMAX; n++ )
  442.     {
  443.     nplus1 = n + 1;
  444.     FastItem[n].NextItem = &FastItem[nplus1];
  445.     FastItem[n].LeftEdge = 0;
  446.     FastItem[n].TopEdge = 9 * n;
  447.     FastItem[n].Width = 80;
  448.     FastItem[n].Height = 9;
  449.     FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  450.     FastItem[n].MutualExclude = (~(1 << n));
  451.     FastItem[n].ItemFill = (APTR)&FastText[n];
  452.     FastItem[n].SelectFill = NULL;
  453.     FastItem[n].Command = 0;
  454.     FastItem[n].NextSelect = 0;
  455.  
  456.     FastText[n].FrontPen = 0;
  457.     FastText[n].BackPen = 1;
  458.     FastText[n].DrawMode = JAM2;
  459.     FastText[n].LeftEdge = 0;
  460.     FastText[n].TopEdge = 1;
  461.     FastText[n].ITextFont = NULL;
  462.     FastText[n].NextText = NULL;
  463.     }
  464. FastItem[FASTMAX-1].NextItem = NULL;
  465.  
  466. /* select fast mem size item checked */
  467. switch (p_fast) {
  468.     case 0:       n = 0; break;
  469.     case 512:     n = 1; break;
  470.     case 1:       n = 2; break;
  471.     case 2:       n = 3; break;
  472.     case 4:       n = 4; break;
  473.     case 6:       n = 5; break;
  474.     case 8:       n = 6; break;
  475.     default:      n = 3; p_fast = 2;
  476.     }
  477. FastItem[n].Flags |= CHECKED;
  478.  
  479. FastText[0].IText = (UBYTE *)"   NONE";
  480. FastText[1].IText = (UBYTE *)"   512K";
  481. FastText[2].IText = (UBYTE *)"   1 MB";
  482. FastText[3].IText = (UBYTE *)"   2 MB";
  483. FastText[4].IText = (UBYTE *)"   4 MB";
  484. FastText[5].IText = (UBYTE *)"   6 MB";
  485. FastText[6].IText = (UBYTE *)"   8 MB";
  486. }
  487.  
  488. /*****************************************************************/
  489. /*    The following initializes the structure arrays             */
  490. /*   needed to provide the Fast Mem Base Addr menu topic.        */
  491. /*****************************************************************/
  492.  
  493. void InitFastAItems()
  494.     {
  495.     int       n,nplus1;
  496.  
  497. /* initialize each menu item and IntuiText with loop */
  498. for( n=0; n<FASTAMAX; n++ )
  499.     {
  500.     nplus1 = n + 1;
  501.     FastAItem[n].NextItem = &FastAItem[nplus1];
  502.     FastAItem[n].LeftEdge = 0;
  503.     FastAItem[n].TopEdge = 9 * n;
  504.     FastAItem[n].Width = 80;
  505.     FastAItem[n].Height = 9;
  506.     FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
  507.     FastAItem[n].MutualExclude = (~(1 << n));
  508.     FastAItem[n].ItemFill = (APTR)&FastAText[n];
  509.     FastAItem[n].SelectFill = NULL;
  510.     FastAItem[n].Command = 0;
  511.     FastAItem[n].NextSelect = 0;
  512.  
  513.     FastAText[n].FrontPen = 0;
  514.     FastAText[n].BackPen = 1;
  515.     FastAText[n].DrawMode = JAM2;
  516.     FastAText[n].LeftEdge = 0;
  517.     FastAText[n].TopEdge = 1;
  518.     FastAText[n].ITextFont = NULL;
  519.     FastAText[n].NextText = NULL;
  520.     }
  521. FastAItem[FASTAMAX-1].NextItem = NULL;
  522.  
  523. /* select fast base address item checked */
  524. switch (p_fasta) {
  525.     case 2:     n = 0; break;
  526.     case 3:     n = 1; break;
  527.     case 4:     n = 2; break;
  528.     case 5:     n = 3; break;
  529.     case 6:     n = 4; break;
  530.     case 7:     n = 5; break;
  531.     case 8:     n = 6; break;
  532.     case 9:     n = 7; break;
  533.     default:    n = 0; p_fasta = 2;
  534.     }
  535. FastAItem[n].Flags |= CHECKED;
  536.  
  537. FastAText[0].IText = (UBYTE *)"   @ 2 M";
  538. FastAText[1].IText = (UBYTE *)"   @ 3 M";
  539. FastAText[2].IText = (UBYTE *)"   @ 4 M";
  540. FastAText[3].IText = (UBYTE *)"   @ 5 M";
  541. FastAText[4].IText = (UBYTE *)"   @ 6 M";
  542. FastAText[5].IText = (UBYTE *)"   @ 7 M";
  543. FastAText[6].IText = (UBYTE *)"   @ 8 M";
  544. FastAText[7].IText = (UBYTE *)"   @ 9 M";
  545. }
  546.  
  547. /****************************************************************/
  548. /*   The following function inits the Menu structure array with */
  549. /*  appropriate values for our simple menu.  Review the manual  */
  550. /*  if you need to know what each value means.                  */
  551. /****************************************************************/
  552. void InitMenu()
  553. {
  554. menu[0].NextMenu = &menu[1];
  555. menu[0].LeftEdge = 4;
  556. menu[0].TopEdge = 0;
  557. menu[0].Width = 64;
  558. menu[0].Height = 10;
  559. menu[0].Flags = MENUENABLED;
  560. menu[0].MenuName = "Project";        /* text for menu-bar display */
  561. menu[0].FirstItem = &ProjItem[0]; /* pointer to first item in list */
  562.  
  563. menu[1].NextMenu = &menu[2];
  564. menu[1].LeftEdge = 68;
  565. menu[1].TopEdge = 0;
  566. menu[1].Width = 48;
  567. menu[1].Height = 10;
  568. menu[1].Flags = MENUENABLED;
  569. menu[1].MenuName = "Setup";   /* text for menu-bar display */
  570. menu[1].FirstItem = &SetupItem[0];  /* pointer to first item in list */
  571.  
  572. menu[2].NextMenu = &menu[3];
  573. menu[2].LeftEdge = 180;
  574. menu[2].TopEdge = 0;
  575. menu[2].Width = 80;
  576. menu[2].Height = 10;
  577. menu[2].Flags = MENUENABLED;
  578. menu[2].MenuName = "Chip Size";        /* text for menu-bar display */
  579. menu[2].FirstItem = &ChipItem[0]; /* pointer to first item in list */
  580.  
  581. menu[3].NextMenu = &menu[4];
  582. menu[3].LeftEdge = 260;
  583. menu[3].TopEdge = 0;
  584. menu[3].Width = 80;
  585. menu[3].Height = 10;
  586. menu[3].Flags = MENUENABLED;
  587. menu[3].MenuName = "Chip Addr";        /* text for menu-bar display */
  588. menu[3].FirstItem = &ChipAItem[0]; /* pointer to first item in list */
  589.  
  590. menu[4].NextMenu = &menu[5];
  591. menu[4].LeftEdge = 340;
  592. menu[4].TopEdge = 0;
  593. menu[4].Width = 64;
  594. menu[4].Height = 10;
  595. menu[4].Flags = MENUENABLED;
  596. menu[4].MenuName = "SF Size";        /* text for menu-bar display */
  597. menu[4].FirstItem = &SFItem[0]; /* pointer to first item in list */
  598.  
  599. menu[5].NextMenu = &menu[6];
  600. menu[5].LeftEdge = 404;
  601. menu[5].TopEdge = 0;
  602. menu[5].Width = 64;
  603. menu[5].Height = 10;
  604. menu[5].Flags = MENUENABLED;
  605. menu[5].MenuName = "SF Addr";        /* text for menu-bar display */
  606. menu[5].FirstItem = &SFAItem[0]; /* pointer to first item in list */
  607.  
  608. menu[6].NextMenu = &menu[7];
  609. menu[6].LeftEdge = 468;
  610. menu[6].TopEdge = 0;
  611. menu[6].Width = 80;
  612. menu[6].Height = 10;
  613. menu[6].Flags = MENUENABLED;
  614. menu[6].MenuName = "Fast Size";      /* text for menu-bar display */
  615. menu[6].FirstItem = &FastItem[0]; /* pointer to first item in list */
  616.  
  617. menu[7].NextMenu = NULL;
  618. menu[7].LeftEdge = 548;
  619. menu[7].TopEdge = 0;
  620. menu[7].Width = 80;
  621. menu[7].Height = 10;
  622. menu[7].Flags = MENUENABLED;
  623. menu[7].MenuName = "Fast Addr";        /* text for menu-bar display */
  624. menu[7].FirstItem = &FastAItem[0]; /* pointer to first item in list */
  625.  
  626. }
  627.  
  628. void StartMenus()
  629. {
  630. SetMenuStrip(window,&menu[0]);
  631. }
  632.